{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Dcl6VOdeVKyH"
      },
      "outputs": [],
      "source": [
        "#超参数定义\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 完整代码"
      ],
      "metadata": {
        "id": "Rdw5-Vihgv4J"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "rdt5J1Nug8DX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "if torch.cuda.is_available():\n",
        "    device = torch.device('cuda')\n",
        "else:\n",
        "    device = torch.device('cpu')\n",
        "    \n",
        "print('Using PyTorch version:', torch.__version__, ' Device:', device)\n",
        "\n",
        "\n",
        "#1.load data\n",
        "#TODO 进行数据增强跑起来试试看！！！\n",
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "batch_size = 128\n",
        "\n",
        "#这是已经划分好训练和测试数据集了的\n",
        "trainset = torchvision.datasets.CIFAR100(root='/content/drive/MyDrive/DeepLearnning/FinalPro/cifar-100-python', train=True,\n",
        "                                        download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR100(root='/content/drive/MyDrive/DeepLearnning/FinalPro/cifar-100-python', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
        "                                         shuffle=False, num_workers=2)\n",
        "\n",
        "classes = {19: 'cattle', 29: 'dinosaur', 0: 'apple', 11: 'boy', 1: 'aquarium_fish', 86: 'telephone',\n",
        "           90: 'train', 28: 'cup', 23: 'cloud', 31: 'elephant', 39: 'keyboard', 96: 'willow_tree', \n",
        "           82: 'sunflower', 17: 'castle', 71: 'sea', 8: 'bicycle', 97: 'wolf', 80: 'squirrel', \n",
        "           74: 'shrew', 59: 'pine_tree', 70: 'rose', 87: 'television', 84: 'table', 64: 'possum', \n",
        "           52: 'oak_tree', 42: 'leopard', 47: 'maple_tree', 65: 'rabbit', 21: 'chimpanzee', \n",
        "           22: 'clock', 81: 'streetcar', 24: 'cockroach', 78: 'snake', 45: 'lobster', 49: 'mountain', \n",
        "           56: 'palm_tree', 76: 'skyscraper', 89: 'tractor', 73: 'shark', 14: 'butterfly', 9: 'bottle', \n",
        "           6: 'bee', 20: 'chair', 98: 'woman', 36: 'hamster', 55: 'otter', 72: 'seal', 43: 'lion', 51: 'mushroom', \n",
        "           35: 'girl', 83: 'sweet_pepper', 33: 'forest', 27: 'crocodile', 53: 'orange', 92: 'tulip', 50: 'mouse', \n",
        "           15: 'camel', 18: 'caterpillar', 46: 'man', 75: 'skunk', 38: 'kangaroo', 66: 'raccoon', 77: 'snail', \n",
        "           69: 'rocket', 95: 'whale', 99: 'worm', 93: 'turtle', 4: 'beaver', 61: 'plate', 94: 'wardrobe', 68: 'road', \n",
        "           34: 'fox', 32: 'flatfish', 88: 'tiger', 67: 'ray', 30: 'dolphin', 62: 'poppy', 63: 'porcupine', 40: 'lamp', \n",
        "           26: 'crab', 48: 'motorcycle', 79: 'spider', 85: 'tank', 54: 'orchid', 44: 'lizard', 7: 'beetle', 12: 'bridge', \n",
        "           2: 'baby', 41: 'lawn_mower', 37: 'house', 13: 'bus', 25: 'couch', 10: 'bowl', 57: 'pear', 5: 'bed', \n",
        "           60: 'plain', 91: 'trout', 3: 'bear', 58: 'pickup_truck', 16: 'can'}"
      ],
      "metadata": {
        "id": "TDc0Irkjvumk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12f59a93-441b-406f-e405-7a6add2284eb"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using PyTorch version: 2.0.0+cu118  Device: cuda\n",
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-100-python.tar.gz to /content/drive/MyDrive/DeepLearnning/FinalPro/cifar-100-python/cifar-100-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 169001437/169001437 [00:02<00:00, 74624254.22it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting /content/drive/MyDrive/DeepLearnning/FinalPro/cifar-100-python/cifar-100-python.tar.gz to /content/drive/MyDrive/DeepLearnning/FinalPro/cifar-100-python\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "#残差块\n",
        "#TODO 看具体残差块含义\n",
        "class BasicBlock(nn.Module):\n",
        "    expansion = 1\n",
        "\n",
        "    def __init__(self, in_channel, out_channel, stride=1):\n",
        "        super(BasicBlock, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(in_channel, out_channel, kernel_size=3,\n",
        "                               stride=stride, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(out_channel)\n",
        "        self.conv2 = nn.Conv2d(out_channel, out_channel, kernel_size=3,\n",
        "                               stride=1, padding=1, bias=False)\n",
        "        self.bn2 = nn.BatchNorm2d(out_channel)\n",
        "        self.shortcut = nn.Sequential()\n",
        "\n",
        "        if stride != 1 or in_channel != self.expansion * out_channel:\n",
        "            self.shortcut = nn.Sequential(\n",
        "                nn.Conv2d(in_channel, self.expansion * out_channel,\n",
        "                          kernel_size=1, stride=stride, bias=False),\n",
        "                nn.BatchNorm2d(self.expansion * out_channel)\n",
        "            )\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = F.relu(self.bn1(self.conv1(x)))\n",
        "        out = self.bn2(self.conv2(out))\n",
        "        out += self.shortcut(x)\n",
        "        out = F.relu(out)\n",
        "        return out"
      ],
      "metadata": {
        "id": "AX6rcbuyv3Zl"
      },
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Net(nn.Module):\n",
        "    def __init__(self, block, num_blocks, num_classes=100):\n",
        "        super(Net, self).__init__()\n",
        "        self.in_channel = 64\n",
        "\n",
        "        self.conv1 = nn.Conv2d(3, 64, kernel_size=3,\n",
        "                               stride=1, padding=1, bias=False)\n",
        "        self.bn1 = nn.BatchNorm2d(64)\n",
        "\n",
        "        self.layer1 = self.make_layer(block, 64, num_blocks[0], stride=1)\n",
        "        self.layer2 = self.make_layer(block, 128, num_blocks[1], stride=2)\n",
        "        self.layer3 = self.make_layer(block, 256, num_blocks[2], stride=2)\n",
        "        self.layer4 = self.make_layer(block, 512, num_blocks[3], stride=2)\n",
        "        self.linear = nn.Linear(512 * block.expansion, num_classes)\n",
        "\n",
        "    def make_layer(self, block, out_channel, num_blocks, stride):\n",
        "        strides = [stride] + (num_blocks - 1) * [1]\n",
        "        layers = []\n",
        "        for stride in strides:\n",
        "            layers.append(block(self.in_channel, out_channel, stride))\n",
        "            self.in_channel = out_channel * block.expansion\n",
        "        return nn.Sequential(*layers)\n",
        "\n",
        "    def forward(self, x):\n",
        "        out = F.relu(self.bn1(self.conv1(x)))\n",
        "        out = self.layer1(out)\n",
        "        out = self.layer2(out)\n",
        "        out = self.layer3(out)\n",
        "        out = self.layer4(out)\n",
        "        out = F.avg_pool2d(out, 4)\n",
        "        out = out.view(out.size(0), -1)\n",
        "        out = self.linear(out)\n",
        "        return out\n",
        "\n",
        "#超参都可以改！！！\n",
        "def ResNet():\n",
        "    return Net(BasicBlock, [2, 2, 2,2])#4个残差块？？？\n",
        "\n",
        "\n",
        "net = ResNet().to(device)\n",
        "\n",
        "#一些超参\n",
        "import torch.optim as optim\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n"
      ],
      "metadata": {
        "id": "bjsw_Rhq4yie"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#注意注意注意： 每次运行这里时 先把前面的above都运行一遍！！！--》即使值改动了epoch 前面的也得执行一遍！！！\n",
        "def validate(loss_vector, accuracy_vector):\n",
        "    net.eval()\n",
        "    total = 0\n",
        "    val_loss, correct = 0, 0\n",
        "    for data, target in testloader:\n",
        "        data = data.to(device)\n",
        "        target = target.to(device)\n",
        "        output = net(data)\n",
        "        val_loss += criterion(output, target).data.item()\n",
        "        _, predicted = torch.max(output.data, 1)\n",
        "        correct += (predicted == target).sum().item()\n",
        "        total += target.size(0)#total就是一个 总数...\n",
        "\n",
        "    val_loss /= total\n",
        "    loss_vector.append(val_loss)\n",
        "\n",
        "    accuracy = 100 * correct / total\n",
        "    accuracy_vector.append(accuracy)\n",
        "\n",
        "    print('\\nValidation set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n",
        "        val_loss, correct, total, accuracy))\n",
        "       \n",
        "#开始训练 \n",
        "lossv, accv = [], []\n",
        "\n",
        "epochs = 5#可调整--这里可以变成train函数\n",
        "#train\n",
        "for epoch in range(epochs):  # loop over the dataset multiple times\n",
        "    \n",
        "\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        # get the inputs; data is a list of [inputs, labels]\n",
        "        inputs, labels = data\n",
        "        inputs = inputs.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # zero the parameter gradients\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        # forward + backward + optimize\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        # print statistics\n",
        "        running_loss += loss.item()\n",
        "        if i % 50 == 49:    # print every 2000 mini-batches\n",
        "            print(f'[{epoch+1}, {i+1:5d}] loss: {running_loss / 2000:.3f}')\n",
        "            running_loss = 0.0\n",
        "    validate(lossv, accv)\n",
        "print('Training Finished')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HyUVHSLyJumX",
        "outputId": "cd54bcfe-52b2-45a1-dee6-be39facad818"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,    50] loss: 0.089\n",
            "[1,   100] loss: 0.089\n",
            "[1,   150] loss: 0.087\n",
            "[1,   200] loss: 0.087\n",
            "[1,   250] loss: 0.085\n",
            "[1,   300] loss: 0.084\n",
            "[1,   350] loss: 0.083\n",
            "\n",
            "Validation set: Average loss: 0.0256, Accuracy: 2153/10000 (22%)\n",
            "\n",
            "[2,    50] loss: 0.080\n",
            "[2,   100] loss: 0.078\n",
            "[2,   150] loss: 0.078\n",
            "[2,   200] loss: 0.075\n",
            "[2,   250] loss: 0.075\n",
            "[2,   300] loss: 0.075\n",
            "[2,   350] loss: 0.074\n",
            "\n",
            "Validation set: Average loss: 0.0232, Accuracy: 2699/10000 (27%)\n",
            "\n",
            "[3,    50] loss: 0.069\n",
            "[3,   100] loss: 0.070\n",
            "[3,   150] loss: 0.071\n",
            "[3,   200] loss: 0.068\n",
            "[3,   250] loss: 0.068\n",
            "[3,   300] loss: 0.066\n",
            "[3,   350] loss: 0.067\n",
            "\n",
            "Validation set: Average loss: 0.0213, Accuracy: 3136/10000 (31%)\n",
            "\n",
            "[4,    50] loss: 0.063\n",
            "[4,   100] loss: 0.062\n",
            "[4,   150] loss: 0.062\n",
            "[4,   200] loss: 0.060\n",
            "[4,   250] loss: 0.061\n",
            "[4,   300] loss: 0.060\n",
            "[4,   350] loss: 0.060\n",
            "\n",
            "Validation set: Average loss: 0.0200, Accuracy: 3533/10000 (35%)\n",
            "\n",
            "[5,    50] loss: 0.056\n",
            "[5,   100] loss: 0.054\n",
            "[5,   150] loss: 0.055\n",
            "[5,   200] loss: 0.054\n",
            "[5,   250] loss: 0.054\n",
            "[5,   300] loss: 0.054\n",
            "[5,   350] loss: 0.055\n",
            "\n",
            "Validation set: Average loss: 0.0183, Accuracy: 3990/10000 (40%)\n",
            "\n",
            "Training Finished\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "plt.figure(figsize=(5,3))\n",
        "plt.plot(np.arange(1,epochs+1), lossv)\n",
        "plt.title('validation loss,epoch=%s'%epochs)\n",
        "\n",
        "plt.figure(figsize=(5,3))\n",
        "plt.plot(np.arange(1,epochs+1), accv)\n",
        "plt.title('validation accuracy,epoch=%s'%epochs)"
      ],
      "metadata": {
        "id": "vVdxQbWO6KGm",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 629
        },
        "outputId": "21cc353e-cfab-46d3-ed9f-7ccab3045e1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'validation accuracy,epoch=5')"
            ]
          },
          "metadata": {},
          "execution_count": 6
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x300 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAEpCAYAAAAEbvI5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8OklEQVR4nO3deViU5f4/8PfMwLCD7Iuyg6Io4IpoCSaJa1GWS5ZLWf1MS7NNO6fQOmWWlaWetM635GQdNctKc0PcF1JBXAAVlE12XABB2eb+/YGMjCwyCMzAvF/XNdclN/c885lb9M3zzPM8H4kQQoCIiEjHSDVdABERkSYwAImISCcxAImISCcxAImISCcxAImISCcxAImISCcxAImISCcxAImISCcxAImISCcxAEkrrVu3DhKJBGlpacqxkJAQhISE3Pe5+/fvh0Qiwf79+1u1JolEgsWLF7fqNptj8eLFkEgk7f66HZ1EIsHcuXM1XQZpMQYgUR3bt2/XSMhRx1P7S1pDj9zcXE2XR82gp+kCiJpr9+7dbf4a27dvx+rVqxsMwVu3bkFPj/9kSNUHH3wAd3d3lbEuXbpophhSC/81U4chl8s1+vqGhoYafX3STqNHj8aAAQM0XQa1AA+B0gPbvHkzJBIJDhw4UO97a9euhUQiwblz5wAAZ86cwYwZM+Dh4QFDQ0M4ODjg+eefx9WrV+/7Og19BnjlyhWEh4fDxMQEdnZ2eP3111FeXl7vuYcOHcLTTz8NFxcXGBgYwNnZGa+//jpu3bqlnDNjxgysXr0aAFQOZ9Vq6DPAU6dOYfTo0TA3N4epqSlGjBiBmJgYlTm1h8qOHDmCBQsWwNbWFiYmJnjiiSdQUFBw3/fdkKqqKnz44Yfw9PSEgYEB3Nzc8O6779Z77ydPnkRYWBhsbGxgZGQEd3d3PP/88ypzNmzYgP79+8PMzAzm5ubo06cPvvrqq2bVsX79evTv3x9GRkawsrLC5MmTkZmZqTInJCQEvXv3RmxsLIYMGaKsY82aNfW2l5+fjxdeeAH29vYwNDSEv78/IiMj681TKBT46quv0KdPHxgaGsLW1hajRo3CyZMn6839/fff0bt3bxgYGMDX1xc7d+5s1ntTR0lJCaqrq1t9u9S2uAdID2zs2LEwNTXFpk2bEBwcrPK9jRs3wtfXF7179wYAREVF4fLly5g5cyYcHByQkJCAb7/9FgkJCYiJiVHrZI9bt25hxIgRyMjIwGuvvQYnJyf8+OOP2Lt3b725v/zyC8rKyjB79mxYW1vj+PHjWLlyJa5cuYJffvkFAPDyyy8jOzsbUVFR+PHHH+/7+gkJCXj44Ydhbm6Ot99+G/r6+li7di1CQkJw4MABBAYGqsx/9dVXYWlpiYiICKSlpWHFihWYO3cuNm7c2Oz3XGvWrFmIjIzEU089hTfeeAN///03li5diqSkJGzZsgVATZiMHDkStra2WLhwIbp06YK0tDT89ttvyu1ERUVhypQpGDFiBJYtWwYASEpKwpEjRzBv3rwma/joo4/w3nvvYeLEiZg1axYKCgqwcuVKDBs2DKdOnVI5DHj9+nWMGTMGEydOxJQpU7Bp0ybMnj0bcrlcGci3bt1CSEgIUlJSMHfuXLi7u+OXX37BjBkzcOPGDZV6XnjhBaxbtw6jR4/GrFmzUFVVhUOHDiEmJkZlb+zw4cP47bff8Morr8DMzAxff/01JkyYgIyMDFhbWwMAKisrUVRU1Kx1t7KyglSqut8wfPhw3Lx5E3K5HGFhYfj888/h7e3drO2RhgmiVjBlyhRhZ2cnqqqqlGM5OTlCKpWKDz74QDlWVlZW77n/+9//BABx8OBB5dgPP/wgAIjU1FTlWHBwsAgODlZ+vWLFCgFAbNq0STlWWloqvLy8BACxb9++Jl936dKlQiKRiPT0dOXYnDlzRGP/LACIiIgI5dfh4eFCLpeLS5cuKceys7OFmZmZGDZsWL33EhoaKhQKhXL89ddfFzKZTNy4caPB16sVERGhUlN8fLwAIGbNmqUy78033xQAxN69e4UQQmzZskUAECdOnGh02/PmzRPm5uYqf2/NkZaWJmQymfjoo49Uxs+ePSv09PRUxoODgwUA8fnnnyvHysvLRUBAgLCzsxMVFRVCiLt/n+vXr1fOq6ioEEFBQcLU1FQUFxcLIYTYu3evACBee+21enXVXV8AQi6Xi5SUFOXY6dOnBQCxcuVK5di+ffsEgGY96v48bty4UcyYMUNERkaKLVu2iH/+85/C2NhY2NjYiIyMDLXWkzSDh0CpVUyaNAn5+fkqlx5s3rwZCoUCkyZNUo4ZGRkp/3z79m0UFhZi8ODBAIC4uDi1XnP79u1wdHTEU089pRwzNjbGSy+9VG9u3dctLS1FYWEhhgwZAiEETp06pdbrAkB1dTV2796N8PBweHh4KMcdHR3xzDPP4PDhwyguLlZ5zksvvaSyh/vwww+juroa6enpar329u3bAQALFixQGX/jjTcAAH/99ReAuydibNu2DZWVlQ1uq0uXLigtLUVUVJRaNfz2229QKBSYOHEiCgsLlQ8HBwd4e3tj3759KvP19PTw8ssvK7+Wy+V4+eWXkZ+fj9jYWOX7cnBwwJQpU5Tz9PX18dprr+HmzZvKQ+y//vorJBIJIiIi6tV17xGE0NBQeHp6Kr/28/ODubk5Ll++rBzz9/dHVFRUsx4ODg7K502cOBE//PADpk2bhvDwcHz44YfYtWsXrl69io8++kit9STN4CFQahWjRo2ChYUFNm7ciBEjRgCoOfwZEBCA7t27K+ddu3YNS5YswYYNG5Cfn6+yjeYehqqVnp4OLy+vev/p9ejRo97cjIwMvP/++/jzzz9x/fr1B3pdACgoKEBZWVmDr9WzZ08oFApkZmbC19dXOe7i4qIyz9LSEgDq1XM/6enpkEql8PLyUhl3cHBAly5dlIEaHByMCRMmYMmSJfjyyy8REhKC8PBwPPPMMzAwMAAAvPLKK9i0aRNGjx6Nrl27YuTIkZg4cSJGjRrVZA3JyckQQjR6qE9fX1/laycnJ5iYmKiM1f5cpKWlYfDgwUhPT4e3t3e9Q4w9e/ZUvm8AuHTpEpycnGBlZdVkjUD9NQdq1r3umltaWiI0NPS+22qOhx56CIGBgdizZ0+rbI/aFgOQWoWBgQHCw8OxZcsW/Pvf/0ZeXh6OHDmCjz/+WGXexIkTcfToUbz11lsICAiAqakpFAoFRo0aBYVC0Sa1VVdX49FHH8W1a9fwzjvvwMfHByYmJsjKysKMGTPa7HXvJZPJGhwXQrRoe/f7vFQikWDz5s2IiYnB1q1bsWvXLjz//PP4/PPPERMTA1NTU9jZ2SE+Ph67du3Cjh07sGPHDuVeTUMnn9RSKBSQSCTYsWNHg+/L1NS0Re+ptTVnzSsqKnDt2rVmbc/W1rbRbdZydnbGhQsXml8kaQwDkFrNpEmTEBkZiejoaCQlJUEIoXL48/r164iOjsaSJUvw/vvvK8eTk5Nb9Hqurq44d+4chBAqYXDvfz5nz57FxYsXERkZiWnTpinHGzrs19yTcGxtbWFsbNzgf3Tnz5+HVCqFs7Nzc9+KWlxdXaFQKJCcnKzcOwKAvLw83LhxA66urirzBw8ejMGDB+Ojjz7Czz//jKlTp2LDhg2YNWsWgJrDkePHj8f48eOhUCjwyiuvYO3atXjvvffq7WXW8vT0hBAC7u7uKnv4jcnOzkZpaanKXuDFixcBAG5ubsr3debMGSgUCpW9wPPnzyu/X/vau3btwrVr15q1F3g/R48exfDhw5s1NzU1VVlvYy5fvgxbW9sHrovaHj8DpFYTGhoKKysrbNy4ERs3bsSgQYNULhCu/c353j2eFStWtOj1xowZg+zsbGzevFk5VlZWhm+//VZlXkOvK4Ro8FT/2v+gb9y40eRry2QyjBw5En/88YfK7dry8vLw888/46GHHoK5ubm6b6lZxowZA6D+un3xxRcAas7KBWp+4bh3rQMCAgBAebnEvZefSKVS+Pn5qcxpyJNPPgmZTIYlS5bUew0hRL3tVlVVYe3atcqvKyoqsHbtWtja2qJ///7K95Wbm6tyVmxVVRVWrlwJU1NT5RnGEyZMgBACS5YsqVdXS/amW/oZYEOXsGzfvh2xsbH3PYRM2oF7gNRq9PX18eSTT2LDhg0oLS3F8uXLVb5vbm6OYcOG4dNPP0VlZSW6du2K3bt3IzU1tUWv9+KLL2LVqlWYNm0aYmNj4ejoiB9//BHGxsYq83x8fODp6Yk333wTWVlZMDc3x6+//trgZ2+1/xm/9tprCAsLg0wmw+TJkxt8/X/961+IiorCQw89hFdeeQV6enpYu3YtysvL8emnn7boPTWHv78/pk+fjm+//RY3btxAcHAwjh8/jsjISISHhyv3ZiIjI/Hvf/8bTzzxBDw9PVFSUoLvvvsO5ubmyhCdNWsWrl27hkceeQTdunVDeno6Vq5ciYCAAJW9y9q9ntqw9/T0xL/+9S8sWrQIaWlpCA8Ph5mZGVJTU7Flyxa89NJLePPNN5XPd3JywrJly5CWlobu3btj48aNiI+Px7fffqv8vPCll17C2rVrMWPGDMTGxsLNzQ2bN2/GkSNHsGLFCpiZmQGouezgueeew9dff43k5GTl4fNDhw5h+PDhat//s6WfAQ4ZMgR9+/bFgAEDYGFhgbi4OHz//fdwdnbGu+++q/b2SAM0cOYpdWJRUVECgJBIJCIzM7Pe969cuSKeeOIJ0aVLF2FhYSGefvppkZ2dXe8Sg+ZcBiGEEOnp6eKxxx5Tnn4+b948sXPnznqXQSQmJorQ0FBhamoqbGxsxIsvvqg8Jf6HH35QzquqqhKvvvqqsLW1FRKJROXyg3trFEKIuLg4ERYWJkxNTYWxsbEYPny4OHr0qMqc2vdy7+UItaff162zIfdeBiGEEJWVlWLJkiXC3d1d6OvrC2dnZ7Fo0SJx+/ZtldqmTJkiXFxchIGBgbCzsxPjxo0TJ0+eVM7ZvHmzGDlypLCzsxNyuVy4uLiIl19+WeTk5Ki8no2NjRg8eHC92n799Vfx0EMPCRMTE2FiYiJ8fHzEnDlzxIULF5RzgoODha+vrzh58qQICgoShoaGwtXVVaxatare9vLy8sTMmTOFjY2NkMvlok+fPip/P7WqqqrEZ599Jnx8fIRcLhe2trZi9OjRIjY2VjkHgJgzZ06957q6uorp06fXX2g1/eMf/xABAQHCwsJC6OvrCxcXFzF79myRm5v7wNum9iERooWfwBORTkhMTISvry+2bdumPLyqjpCQEBQWFirvBkSkLfgZIBE1ad++fQgKCmpR+BFpM+4BElGb4h4gaSvuARIRkU7iHiAREekk7gESEZFOYgASEZFO6jQXwisUCmRnZ8PMzEytnnJERNR5CCFQUlICJyenejdWv1enCcDs7Ow2u/ciERF1LJmZmejWrVuTczpNANbeJikzM7PN7sFIRETarbi4GM7OzspMaEqnCcDaw57m5uYMQCIiHdecj8J4EgwREekkBiAREekkBiAREekkBiAREekkBiAREekkBiAREekkBmAdV2+W46e/0zVdBhERtYNOcx3ggyq5XYnQLw7gelkl3KxNMNTLRtMlERFRG+Ie4B1mhvoY7+8EAFiyNQGV1QoNV0RERG2JAVjHgke7w9JYHxfzbuLHYzwUSkTUmTEA6+hiLMdbYT4AgC/3XEThzXINV0RERG2FAXiPSQOd0burOUpuV+GznRc0XQ4REbURBuA9ZFIJljzmCwDYFJuJ05k3NFsQERG1CQZgA/q7WuHJvl0hBPD+nwlQKISmSyIiolbGAGzEwtE+MJHLcDrzBn6Nu6LpcoiIqJUxABthZ26I10Z4AwCW7TyP4tuVGq6IiIhaEwOwCTOHusPDxgSFNyvw1Z5kTZdDREStiAHYBLmeFO+P7wUAiDyahuS8Eg1XRERErYUBeB8hPewQ2tMeVQqBJVsTIQRPiCEi6gwYgM3w/rhekOtJcTilELsScjVdDhERtQIGYDO4WBvjpYc9AAAfbkvC7cpqDVdEREQPigHYTK8M94SThSGybtzCmgOXNF0OERE9IAZgMxnL9fDu2J4AgG/2X0LmtTINV0RERA+CAaiGsX0cMdjDCuVVCny8PUnT5RAR0QNgAKpBIpFg8WO+kEkl2HEuF0dSCjVdEhERtRADUE0+DuZ4brArACDiTzbOJSLqqBiALfB6aHdYmciRkn8T/2XjXCKiDokB2AIWxvp4K6wHAGBF1EUUlLBxLhFRR8MAbKGJA5zRp6sFSsqr8OnO85ouh4iI1MQAbCGZtOaEGAD4JfYK4tk4l4ioQ2EAPoD+rpZ4sl9XAEDEH+fYOJeIqANhAD6ghaN8YGqgh9NXirA5lo1ziYg6CgbgA6ppnOsFoKZxbtEtNs4lIuoIGICtYMYQd3jYmuBqKRvnEhF1FAzAViDXkyJifM0JMZHH2DiXiKgjYAC2kuDutni0lz2qFQKLtyawcS4RkZZjALai98bWNM49knIVO8+xcS4RkTZjALYiF2tjvDyspnHuv/5Kwq0KNs4lItJWDMBW9kqIFxvnEhF1AAzAVmYkl+EfY3sBANYcYONcIiJtxQBsA2P6OCDIwxrlVQp89Bcb5xIRaSMGYBuo2zh3Z0IuDiezcS4RkbZhALaRHg5mysa5i7eycS4RkbZpUQCuXr0abm5uMDQ0RGBgII4fP97o3ISEBEyYMAFubm6QSCRYsWJFvTnV1dV477334O7uDiMjI3h6euLDDz/s8NfS1W2cG3k0TdPlEBFRHWoH4MaNG7FgwQJEREQgLi4O/v7+CAsLQ35+foPzy8rK4OHhgU8++QQODg4Nzlm2bBm++eYbrFq1CklJSVi2bBk+/fRTrFy5Ut3ytIqFsT7evtM496s9yWycS0SkRdQOwC+++AIvvvgiZs6ciV69emHNmjUwNjbG999/3+D8gQMH4rPPPsPkyZNhYGDQ4JyjR4/i8ccfx9ixY+Hm5oannnoKI0eObHLPsqOYOMAZft1qGucuY+NcIiKtoVYAVlRUIDY2FqGhoXc3IJUiNDQUx44da3ERQ4YMQXR0NC5evAgAOH36NA4fPozRo0c3+pzy8nIUFxerPLSRtE7j3M2xV3Aq47qGKyIiIkDNACwsLER1dTXs7e1Vxu3t7ZGb2/Jbfy1cuBCTJ0+Gj48P9PX10bdvX8yfPx9Tp05t9DlLly6FhYWF8uHs7Nzi129r/VwsMaFfNwDA4j8T2DiXiEgLaMVZoJs2bcJPP/2En3/+GXFxcYiMjMTy5csRGRnZ6HMWLVqEoqIi5SMzM7MdK1bfO6N7KBvn/hKr3bUSEekCPXUm29jYQCaTIS8vT2U8Ly+v0RNcmuOtt95S7gUCQJ8+fZCeno6lS5di+vTpDT7HwMCg0c8UtZGdmSHmjfDGR9uT8OnOCxjV2xEWRvqaLouISGeptQcol8vRv39/REdHK8cUCgWio6MRFBTU4iLKysoglaqWIpPJoFB0rmvnpg9xg+edxrkr9lzUdDlERDpN7UOgCxYswHfffYfIyEgkJSVh9uzZKC0txcyZMwEA06ZNw6JFi5TzKyoqEB8fj/j4eFRUVCArKwvx8fFISUlRzhk/fjw++ugj/PXXX0hLS8OWLVvwxRdf4IknnmiFt6g95HpS5Qkx/z2Wjgu5bJxLRKQpEtGCq81XrVqFzz77DLm5uQgICMDXX3+NwMBAAEBISAjc3Nywbt06AEBaWhrc3d3rbSM4OBj79+8HAJSUlOC9997Dli1bkJ+fDycnJ0yZMgXvv/8+5HJ5s2oqLi6GhYUFioqKYG5uru5balcv/fckdifmYYinNX6aFQiJRKLpkoiIOgV1sqBFAaiNOlIAZl4rQ+gXB1BepcC/p/bDmD6Omi6JiKhTUCcLtOIsUF3jbGWMl4M9AQAfsXEuEZFGMAA1ZHawJ7p2MULWjVv4ho1ziYjaHQNQQ2oa5/YEwMa5RESawADUoNG9HTDE0xoVVQr8669ETZdDRKRTGIAaVLdx7q6EPBxKLtB0SUREOoMBqGHd7c0wLehO49w/E1BR1bku/ici0lYMQC0wP7Q7rE3kuFRQiv8eS9N0OUREOoEBqAUsjPTx9qiaxrkr9iQjv+S2hisiIur8GIBa4un+zvDvZoGb5VVYtuOCpsshIur0GIBaom7j3F/jriCOjXOJiNoUA1CL9HWxxFP92TiXiKg9MAC1zDujfGBmoIczV4qw6SQb5xIRtRUGoJaxNTPAvFBvAMCnuy6g6FalhisiIuqcGIBaaPoQN3jZmeJaaQW+jGLjXCKitsAA1EL6MikixvcCAPwYw8a5RERtgQGopR72tkWYrz2qFQKL/0xAJ2nbSESkNRiAWuyfY3vBQE+KY5evYvvZXE2XQ0TUqTAAtZizlTH+n7JxbiLKKqo0XBERUefBANRy/+9O49zsottYs5+Nc4mIWgsDUMsZyWX4Z23j3IOXkXGVjXOJiFoDA7ADGNXbAUO9ahrnfsjGuURErYIB2AFIJBJEjK9pnBuVmIcDF9k4l4joQTEAO4ju9maYHuQGAFiylY1ziYgeFAOwA5n/qDdsTOW4XFCKdUdTNV0OEVGHxgDsQMwN9fF2mA8A4Ks9ycgvZuNcIqKWYgB2ME/17wZ/5y4orajGJzvPa7ocIqIOiwHYwUilEiy50zj3t7gsxKazcS4RUUswADugAOcueLpO49xqNs4lIlIbA7CDevtO49yzWWycS0TUEgzADsrWzADzH+0OAPhs1wUUlbFxLhGROhiAHdi0IFd41zbO3cPGuURE6mAAdmD6MikW3zkh5seYdJzPLdZwRUREHQcDsIMb6mWD0b0d2DiXiEhNDMBO4N0xPWGgJ0XM5Wv462yOpsshIuoQGICdgLOVMWaH1DbOTWLjXCKiZmAAdhK1jXNzim7jGzbOJSK6LwZgJ2GoL8N742oa565l41wiovtiAHYiYb4OeMjLBhVVCnywjY1ziYiawgDsRCQSCRY/1gt6Ugn2JOVh/4V8TZdERKS1GICdjJedGaYPcQMAfLA1kY1ziYgawQDshOaFesPG1ACXC0vxwxE2ziUiaggDsBMyN9THO6N6AAC+jmbjXCKihjAAO6kJ/bohoLZx7g42ziUiuhcDsJOqbZwrkQC/ncpCbPo1TZdERKRVWhSAq1evhpubGwwNDREYGIjjx483OjchIQETJkyAm5sbJBIJVqxY0eC8rKwsPPvss7C2toaRkRH69OmDkydPtqQ8usPfuQsm9ncGAESwcS4RkQq1A3Djxo1YsGABIiIiEBcXB39/f4SFhSE/v+FT7svKyuDh4YFPPvkEDg4ODc65fv06hg4dCn19fezYsQOJiYn4/PPPYWlpqW55dI+3RvWAmaEezmUVY+MJNs4lIqolEWq2DwgMDMTAgQOxatUqAIBCoYCzszNeffVVLFy4sMnnurm5Yf78+Zg/f77K+MKFC3HkyBEcOnRIverrKC4uhoWFBYqKimBubt7i7XRG3x9OxQfbEmFprI99b4agi7Fc0yUREbUJdbJArT3AiooKxMbGIjQ09O4GpFKEhobi2LFjLasWwJ9//okBAwbg6aefhp2dHfr27YvvvvuuxdsjVc8FuaK7vSmul1Xiyyg2ziUiAtQMwMLCQlRXV8Pe3l5l3N7eHrm5uS0u4vLly/jmm2/g7e2NXbt2Yfbs2XjttdcQGRnZ6HPKy8tRXFys8qCG6cukWDz+buPcpByuFRGRVpwFqlAo0K9fP3z88cfo27cvXnrpJbz44otYs2ZNo89ZunQpLCwslA9nZ+d2rLjjGeJlgzF9HKAQNSfEsHEuEek6tQLQxsYGMpkMeXl5KuN5eXmNnuDSHI6OjujVq5fKWM+ePZGRkdHocxYtWoSioiLlIzOTJ3jcz7tjesJQX4rjqdew7Qwb5xKRblMrAOVyOfr374/o6GjlmEKhQHR0NIKCglpcxNChQ3HhwgWVsYsXL8LV1bXR5xgYGMDc3FzlQU3rZmmM2cFeAICPt7NxLhHpNrUPgS5YsADfffcdIiMjkZSUhNmzZ6O0tBQzZ84EAEybNg2LFi1Szq+oqEB8fDzi4+NRUVGBrKwsxMfHIyUlRTnn9ddfR0xMDD7++GOkpKTg559/xrfffos5c+a0wlukul4O9kA3y5rGuf/ex8a5RKTDRAusXLlSuLi4CLlcLgYNGiRiYmKU3wsODhbTp09Xfp2amioA1HsEBwerbHPr1q2id+/ewsDAQPj4+Ihvv/1WrZqKiooEAFFUVNSSt6RTdpzNEa7vbBPe724XaYU3NV0OEVGrUScL1L4OUFvxOsDmE0Jg2vfHcSi5EKE97fCf6QM1XRIRUatos+sAqXOQSCSIGF/bODcf+9g4l4h0EANQR3nZmWHGnca5H7JxLhHpIAagDqvbOPd7Ns4lIh3DANRhZob6WDjaBwCwMjoZeWycS0Q6hAGo457s2xV9Xdg4l4h0DwNQx9VtnLvlVBZOprFxLhHpBgYgwa9bF0wawMa5RKRbGIAEAHgzrKZxbkJ2MTacaPwerEREnQUDkAAANqYGWPBodwDA8l0XcKOsQsMVERG1LQYgKT03+G7j3C/YOJeIOjkGICnpyaRY/FhN49z1MelIzGbjXCLqvBiApGKIpw3G9nGEQgCL2TiXiDoxBiDV8+7YO41z065hKxvnElEnxQCkerp2McIrIXca5/6VhNJyNs4los6HAUgNemmYB5ytjJBbfBur96Xc/wlERB0MA5AaZKgvw3tjewEA/nMoFWmFpRquiIiodTEAqVGP9rLHw942qKhW4MNtiZouh4ioVTEAqVE1jXN9oSeVIPp8PvadZ+NcIuo8GIDUJC87Uzz/kDsA4INtiSivqtZwRURErYMBSPf16iNesDUzQGphKb4/nKbpcoiIWgUDkO7LzFAfC0fdaZy7l41ziahzYABSszzRtyv6uXRBWUU1lm5P0nQ5REQPjAFIzVLTOLc3JBLg9/hsnGDjXCLq4BiA1Gx9ullg8sA7jXP/YONcIurYGICkljdH9oC5oR4Sc4rxv+NsnEtEHRcDkNRiXbdx7u4LuF7KxrlE1DExAEltzw52hY+DGW6wcS4RdWAMQFKbnkyKiPE1jXN/+puNc4moY2IAUosEeVpjrB8b5xJRx8UApBb7x5i7jXP/PJ2t6XKIiNTCAKQWc+pihDm1jXO3s3EuEXUsDEB6IC8O84CLlTHyisuxio1ziagDYQDSAzHUl+G9cTWNc//vUCpS2TiXiDoIBiA9sNCedhjW3ZaNc4moQ2EA0gOraZzbC/oyCfaez8fe83maLomI6L4YgNQqPG1N8fzQO41zt7JxLhFpPwYgtZq5dxrnpl0tw/8dTtV0OURETWIAUqsxM9THotE1jXNX7U1BbhEb5xKR9mIAUqtSaZy7g41ziUh7MQCpVUkkEnzweE3j3D/is3E8lY1ziUg7MQCp1fXuaoHJA10AABF/snEuEWknBiC1ibfCahrnJuUU42c2ziUiLcQApDZhZSLHGyN7AAA+Z+NcItJCDEBqM1MDXZSNc5fvvqDpcoiIVDAAqc3oyaRY/FhN49yfj2fgXFaRhisiIrqrRQG4evVquLm5wdDQEIGBgTh+/HijcxMSEjBhwgS4ublBIpFgxYoVTW77k08+gUQiwfz581tSGmmZwR7WGOfnCCGAJVvZOJeItIfaAbhx40YsWLAAERERiIuLg7+/P8LCwpCfn9/g/LKyMnh4eOCTTz6Bg4NDk9s+ceIE1q5dCz8/P3XLIi32j7E9YaQvw4m062ycS0RaQ+0A/OKLL/Diiy9i5syZ6NWrF9asWQNjY2N8//33Dc4fOHAgPvvsM0yePBkGBgaNbvfmzZuYOnUqvvvuO1haWqpbFmkxRwsjzH3kbuPcs1d4KJSINE+tAKyoqEBsbCxCQ0PvbkAqRWhoKI4dO/ZAhcyZMwdjx45V2XZTysvLUVxcrPIg7fXCQ+5wta5pnDt+1WE8vuowNp3MxK0K3jSbiDRDrQAsLCxEdXU17O3tVcbt7e2Rm5vb4iI2bNiAuLg4LF26tNnPWbp0KSwsLJQPZ2fnFr8+tT1DfRkiZw7CY/5O0JdJcPpKEd7efAaBH+/BB1sTcangpqZLJCIdo/GzQDMzMzFv3jz89NNPMDQ0bPbzFi1ahKKiIuUjMzOzDauk1uBmY4Kvp/TFsUUj8PaoHuhmaYTi21X4/kgqRnx+AFP/E4MdZ3NQWa3QdKlEpAP01JlsY2MDmUyGvDzVhqd5eXn3PcGlMbGxscjPz0e/fv2UY9XV1Th48CBWrVqF8vJyyGSyes8zMDBo8jNF0l42pgZ4JcQLLw/zxIGL+Vgfk4F9F/JxJOUqjqRchZ2ZASYPcsGUQc5wtDDSdLlE1EmpFYByuRz9+/dHdHQ0wsPDAQAKhQLR0dGYO3duiwoYMWIEzp49qzI2c+ZM+Pj44J133mkw/KhzkEkleMTHHo/42CPzWhn+dzwDm05mIr+kHF9HJ2P1vhSM8LHDc0GuGOppA6lUoumSiagTUSsAAWDBggWYPn06BgwYgEGDBmHFihUoLS3FzJkzAQDTpk1D165dlZ/nVVRUIDExUfnnrKwsxMfHw9TUFF5eXjAzM0Pv3r1VXsPExATW1tb1xqnzcrYyxtujfDA/tDt2JuRifUw6jqdew+7EPOxOzIObtTGmBrriqf7dYGki13S5RNQJqB2AkyZNQkFBAd5//33k5uYiICAAO3fuVJ4Yk5GRAan07keL2dnZ6Nu3r/Lr5cuXY/ny5QgODsb+/fsf/B1QpyLXk+Ixfyc85u+EC7kl+OnvdPwWl4W0q2X4aHsSPtt9AeP8HPHsYFf0de4CiYR7hUTUMhLRSW7NUVxcDAsLCxQVFcHc3FzT5VArKi2vwh/x2Vgfk47EnLuXu/g6mePZwa54PMAJxnK1f5cjok5InSxgAFKHIYTAqcwbWB+Tjm1nclBRVXO2qJmBHp7s1xXPDnaFt72ZhqskIk1iADIAO73rpRX4JTYTP/2dgfSrZcrxQe5WeHawK0b5OkCup/GrfIionTEAGYA6Q6EQOJxSiPUx6diTlIfa5vM2pnJMGuiMKYNc0M3SWLNFElG7YQAyAHVSTtEt/O94JjYcz0B+STkAQCoBhveww7ODXTGsuy1kvJSCqFNjADIAdVpltQJRiXlYH5OOo5euKse7WRrhmUAXTBzgDBtT3kSBqDNiADIA6Y5LBTfxU0wGNsdmovh2FQBALpNidB8HPDvYFQNcLXkpBVEnwgBkANI9blVUY+uZbPwUk47Tddox9bA3w7ODXRDetyvMDPU1WCERtQYGIAOQmnDmSs2lFH+ezsbtyppLKUzkMoT3rbmUoqcjf36IOioGIAOQmqGorBK/xl3B+r/TcbmgVDne39USzw52wejejjDU571oiToSBiADkNQghMCxS1ex/u907E7IQ9WdayksjfUxcYAzngl0gau1iYarJKLmYAAyAKmF8otvY8OJTPzveAZyim4rx4O72+LZwa54xMeOl1IQaTEGIAOQHlBVtQJ7z+dj/d8ZOHixQDnuZGGIKYNcMGmQM+zMmt/AmYjaBwOQAUitKK2wFD8fz8AvJzNxvawSAKAnlSDM1wFTB7sgyMOal1IQaQkGIAOQ2sDtympsP5uD9THpiMu4oRz3sjPF1EAXPNmvGyyMeCkFkSYxABmA1MYSs4ux/u90/H4qC2UV1QAAI30ZHvN3wrODXdGnm4WGKyTSTQxABiC1k5LbldhyKgvrY9JxMe+mctzfuQueDXTBeH8nXkpB1I4YgAxAamdCCJxIu471MenYcS4HldU1/6wsjPTxVP9umBroAg9bUw1XSdT5MQAZgKRBhTfLselkJn7+OwNXrt9Sjg/1ssazga4I7WUPfRl7FRK1BQYgA5C0QLVC4MDFfKyPycC+C/mo/Zdmb26AyQNdMGWQCxwseCkFUWtiADIASctkXivD/45nYNPJTBTerAAAyKQShPas6VU41NMGUl5gT/TAGIAMQNJSFVUK7EzIxfqYdBxPvaYcd7cxwTODXPBU/26wNJFrsEKijo0ByACkDuBCbgl++jsdv8Vl4Wb5nV6FelKM93PCs4NdEODchRfYk84ovl2J3Ql5GORmBRdr45ZvhwHIAKSOo7S8Cn/EZ2N9TDoSc4qV475O5nh2sCseD3CCsVxPgxUStY3S8irsScrDtjM5OHChABXVCswb4Y3XH+3e4m0yABmA1AEJIXAqs6ZX4bYzOaioqulVaGaghwl3LqXwtjfTcJVED+Z2ZTX2nc/HtjM5iD6fp+zJCdTcVen5oe54JtClxdtnADIAqYO7XlqBX2Iz8dPfGUi/WqYcD3S3wrODXRHm6wC5Hi+loI6hvKoahy4WYtuZbEQl5qH0zt2TAMDV2hjj/Zwwzt8RPezNHviwPwOQAUidhEIhcDilEOtj0rEnKQ93WhXCxtQAkwZ2w5RBLuhm2fLPS4jaSmW1AkcvXcW209nYmZCLkttVyu917WKEcX6OGOfnhN5dzVv1s24GIAOQOqGcolv43/FMbDiegfyScgCAVAI84mOHqYNdEexty0spSKOqFQJ/p17FtjM52HE2R9k9BQDszAww9k7o9XNpuxO8GIAMQOrEKqsViErMw/qYdBy9dFU57mxlhMkDXTCylz287Ex5Bim1C4VCIC7jOradycFfZ3NQcOeXMwCwNpFjdB8HjPNzwkA3q3ZpJs0AZACSjrhUcBM/xWRgc2wmiuscYnIwN8TD3jYY1t0WQ71sYMVrC6kVCSFw5koRtp3JxrYzOcgpuq38noWRPkb5OmCcvyOCPKyh1863/WMAMgBJx9yqqMbW09nYeiYbx1Ovobzq7pl1EgnQp6tFTSB626KviyVPoCG1CSGQlFOiDL2Ma3dPzjI10MPIXvYY5++Ih7xsNfrzxQBkAJIOu11ZjeOp13AouQCHkgtxPrdE5fsmchmCPK0xrLstHva2hZu1MQ+XUqOS80qw9UwOtp3JxuWCUuW4kb4MI3raYZyfE0J62GpN2y8GIAOQSCmv+DYOJRfiUHIBDicX4mpphcr3u1ka4WFvWwR3t0GQpw272hPSCkuVe3p1f4GS60kxvIctxvk5YURPO628QQMDkAFI1CCFQiAxpxgHkwtw6GIhTqZfU/YuBGrOKg1w7qLcO/TvZtHun+GQZly5Xoa/zuRg25kcnM0qUo7ryyR42NsW4/wc8Wgve5gZavcvSAxABiBRs5SWV+Hv1Ks4eLFmD/FSnUNcAGBmqIehnjZ3AtEGzla85rAzySu+fSf0shGXcUM5LpNKMMTTGuP9nBDm6wALY+0OvboYgAxAohbJunELhy7WfHZ4OKUQRbcqVb7vbmOiPJlmsKc1TA207xAYNa3wZjl2nMvFttPZOJ52TdmnUiIBBrlZYZy/E0b3doCNqYFmC20hBiADkOiBVSsEzmYV4eDFAhxKLkBcxg1UK+7+d6EnlaCfqyWC7+wd9nay4IX4WupGWQV2JeRi25kcHL10VeXvsZ9LF4z3d8KYPo6wN+/4DZoZgAxAolZXfLsSMZeu1nx+mFyoco9SALA01sdQr7uHSx0tjDRUKQFAye1KRCXWdFo4lFyg8llvn64WGO/viDF9HDvdrfQYgAxAojaXfrUUB5MLcehiAY5euqrsaVjL285UGYaB7tYwkmvHafKdWVlFFaKT8rHtTDb2XShQdhQBAB8HM4z3d8LYPo5wszHRYJVtiwHIACRqV5XVCpzOvIGDFwtwMLkQZ67cQJ2jbJDLpBjobolh3jVnl/Z0fPC7/lON25XV2H+hANvOZCM6KR+3Ku92WvCwNcF4PyeM93eEl51utNJiADIAiTTqRlkFjqRcxaHkAhy8WIDsOrfKAmq6WdTcqs0GD3nZwtasY55woSkVVQocTinAttM52J2Yp7L37WJlrOy0oIu/aDAAGYBEWkMIgcuFpXdOpinEsUtXVfZSAKCnozmG3bl3aX9XS625q4g2qapW4Njlq9h6Ohu7EvJUztB1sjBUdlrw62ahc6FXFwOQAUiktcqrqhGXfuPOyTQFOJdVrPJ9Q30pAt1rbtU2zNtGpztbVCsETqRdw9bT2dh5LlflLj62ZgYY28cR4/wc0c/Fkmfg3sEAZAASdRiFN8txJKVQeTF+fp12OoDudbYQQiAu4wa2ns7G9rM5KuthaayP0XdCL9Ddul3aC3U0DEAGIFGHJITAxbybd06mKdCZzhZCCJzLKsbWM9n460wOsm7cUn7P3FAPYb4OGOfvhCGe1tDnrema1OYBuHr1anz22WfIzc2Fv78/Vq5ciUGDBjU4NyEhAe+//z5iY2ORnp6OL7/8EvPnz1eZs3TpUvz22284f/48jIyMMGTIECxbtgw9evRodk0MQKLO53ZlNU6kXVN+ftiZOlsIIXA+9257obrXVZrIZXi0lz3G+Tnh4e42MNDjZ6LNpU4WqH0fo40bN2LBggVYs2YNAgMDsWLFCoSFheHChQuws7OrN7+srAweHh54+umn8frrrze4zQMHDmDOnDkYOHAgqqqq8O6772LkyJFITEyEiUnnvV6FiJpmqC/Dw3cunQAa7myxJykfe5LyAXSMzhYp+TeVoZeSf1M5bqgvxQgfe4zzc8RwHzueCNQO1N4DDAwMxMCBA7Fq1SoAgEKhgLOzM1599VUsXLiwyee6ublh/vz59fYA71VQUAA7OzscOHAAw4YNa1Zd3AMk0i0dqbNFxtUybL0Tekk5d0/6kcukCO5hi/H+ThjhYwcT3lv1gbXZHmBFRQViY2OxaNEi5ZhUKkVoaCiOHTvWsmobUFRU04rDysqq1bZJRJ2LVCpB764W6N3VAq+EeDXY2SIu4wbiMm5gxZ7kdu9skX3jlrLTwukrd9sL6UkleMjbBuP9nPCorz3Mtby9UGemVgAWFhaiuroa9vb2KuP29vY4f/58qxSkUCgwf/58DB06FL179250Xnl5OcrL754dVVxc3OhcIur8TAz08IiPPR7xqfn/KevGLRxOLsDBi3c7W+xMyMXOhFwAbdPZIr/kNrbf6al3Mv26clwqAYLqtBey7ORnsnYUWre/PWfOHJw7dw6HDx9uct7SpUuxZMmSdqqKiDqarl2MMGmgCyYNdGmws0VqYSlSC0vx32PpD9TZ4lppBXacy8G20zmISb2q0l5ooKsVxvs7YlRvR97tRgupFYA2NjaQyWTIy8tTGc/Ly4ODg8MDFzN37lxs27YNBw8eRLdu3Zqcu2jRIixYsED5dXFxMZydnR+4BiLqfGRSCQKcuyDAuQteG+HdYGeL46nXcDz1Gj7bdeG+nS2KblUq2wsdSSlUaS8U4NxFedNpB4uO316oM1MrAOVyOfr374/o6GiEh4cDqDlkGR0djblz57a4CCEEXn31VWzZsgX79++Hu7v7fZ9jYGAAAwP+RkVE6jM31MdIXweM9K35xf3ezhbXyyqx7c6hTKCms8XD3rbwsjPF3vN5OHBRtb2Qr5O5MvTa+rNFaj1qHwJdsGABpk+fjgEDBmDQoEFYsWIFSktLMXPmTADAtGnT0LVrVyxduhRAzYkziYmJyj9nZWUhPj4epqam8PLyAlBz2PPnn3/GH3/8ATMzM+Tm1hyjt7CwgJERe4oRUdtytTbBc9YmeG6wa4OdLZLzbyK5ziULANDd3hTj/Zww1s8RHramGqqcHkSLLoRftWqV8kL4gIAAfP311wgMDAQAhISEwM3NDevWrQMApKWlNbhHFxwcjP3799cU0ciFqz/88ANmzJjRrJp4GQQRtYUbZRU4eukqDl4swKWCmwjysMY4fyd0t9eN9kIdDW+FxgAkItJJ6mQBbypHREQ6iQFIREQ6iQFIREQ6iQFIREQ6iQFIREQ6iQFIREQ6iQFIREQ6Setuht1StZczsisEEZHuqs2A5lzi3mkCsKSkBAB4Q2wiIkJJSQksLCyanNNp7gSjUCiQnZ0NMzOzRm+tdj+1HSUyMzM7xN1kWG/bYr1ti/W2LV2tVwiBkpISODk5QSpt+lO+TrMHKJVK79tCqbnMzc07xA9MLdbbtlhv22K9bUsX673fnl8tngRDREQ6iQFIREQ6iQFYh4GBASIiIjpMo13W27ZYb9tivW2L9d5fpzkJhoiISB3cAyQiIp3EACQiIp3EACQiIp3EACQiIp2kUwF48OBBjB8/Hk5OTpBIJPj999/v+5z9+/ejX79+MDAwgJeXF9atW9fmddZSt979+/dDIpHUe+Tm5rZ5rUuXLsXAgQNhZmYGOzs7hIeH48KFC/d93i+//AIfHx8YGhqiT58+2L59e5vXCrSs3nXr1tVbW0NDw3ap95tvvoGfn5/yIuGgoCDs2LGjyedoam1rqVuzJtf3Xp988gkkEgnmz5/f5DxNr3Gt5tSr6fVdvHhxvdf38fFp8jltvb46FYClpaXw9/fH6tWrmzU/NTUVY8eOxfDhwxEfH4/58+dj1qxZ2LVrVxtXWkPdemtduHABOTk5yoednV0bVXjXgQMHMGfOHMTExCAqKgqVlZUYOXIkSktLG33O0aNHMWXKFLzwwgs4deoUwsPDER4ejnPnzmllvUDNXSrqrm16enqb1woA3bp1wyeffILY2FicPHkSjzzyCB5//HEkJCQ0OF+Ta9vSmgHNrW9dJ06cwNq1a+Hn59fkPG1YY6D59QKaX19fX1+V1z98+HCjc9tlfYWOAiC2bNnS5Jy3335b+Pr6qoxNmjRJhIWFtWFlDWtOvfv27RMAxPXr19ulpqbk5+cLAOLAgQONzpk4caIYO3asylhgYKB4+eWX27q8eppT7w8//CAsLCzar6j7sLS0FP/5z38a/J42rW1dTdWsDetbUlIivL29RVRUlAgODhbz5s1rdK42rLE69Wp6fSMiIoS/v3+z57fH+urUHqC6jh07htDQUJWxsLAwHDt2TEMVNU9AQAAcHR3x6KOP4siRIxqpoaioCABgZWXV6BxtWt/m1AsAN2/ehKurK5ydne+7N9NWqqursWHDBpSWliIoKKjBOdq0tkDzagY0v75z5szB2LFj661dQ7RhjdWpF9D8+iYnJ8PJyQkeHh6YOnUqMjIyGp3bHuvbaW6G3RZyc3Nhb2+vMmZvb4/i4mLcunULRkZGGqqsYY6OjlizZg0GDBiA8vJy/Oc//0FISAj+/vtv9OvXr93qUCgUmD9/PoYOHYrevXs3Oq+x9W2Pzyzram69PXr0wPfffw8/Pz8UFRVh+fLlGDJkCBISElrtRuxNOXv2LIKCgnD79m2Ymppiy5Yt6NWrV4NztWVt1alZ0+u7YcMGxMXF4cSJE82ar+k1VrdeTa9vYGAg1q1bhx49eiAnJwdLlizBww8/jHPnzsHMzKze/PZYXwZgJ9KjRw/06NFD+fWQIUNw6dIlfPnll/jxxx/brY45c+bg3LlzTR7f1ybNrTcoKEhl72XIkCHo2bMn1q5diw8//LCty0SPHj0QHx+PoqIibN68GdOnT8eBAwcaDRRtoE7NmlzfzMxMzJs3D1FRURo78UYdLalX0z+/o0ePVv7Zz88PgYGBcHV1xaZNm/DCCy+0+es3hAHYBAcHB+Tl5amM5eXlwdzcXOv2/hozaNCgdg2iuXPnYtu2bTh48OB9f6tsbH0dHBzaskQV6tR7L319ffTt2xcpKSltVJ0quVwOLy8vAED//v1x4sQJfPXVV1i7dm29udqwtoB6Nd+rPdc3NjYW+fn5KkdKqqurcfDgQaxatQrl5eWQyWQqz9HkGrek3nu198/vvbp06YLu3bs3+vrtsb78DLAJQUFBiI6OVhmLiopq8jMMbRMfHw9HR8c2fx0hBObOnYstW7Zg7969cHd3v+9zNLm+Lan3XtXV1Th79my7rG9DFAoFysvLG/yetv7sNlXzvdpzfUeMGIGzZ88iPj5e+RgwYACmTp2K+Pj4BsNEk2vcknrvpemf35s3b+LSpUuNvn67rG+rnU7TAZSUlIhTp06JU6dOCQDiiy++EKdOnRLp6elCCCEWLlwonnvuOeX8y5cvC2NjY/HWW2+JpKQksXr1aiGTycTOnTu1st4vv/xS/P777yI5OVmcPXtWzJs3T0ilUrFnz542r3X27NnCwsJC7N+/X+Tk5CgfZWVlyjnPPfecWLhwofLrI0eOCD09PbF8+XKRlJQkIiIihL6+vjh79qxW1rtkyRKxa9cucenSJREbGysmT54sDA0NRUJCQpvXu3DhQnHgwAGRmpoqzpw5IxYuXCgkEonYvXt3g7Vqcm1bWrMm17ch955VqY1rXNf96tX0+r7xxhti//79IjU1VRw5ckSEhoYKGxsbkZ+f32C97bG+OhWAtZcJ3PuYPn26EEKI6dOni+Dg4HrPCQgIEHK5XHh4eIgffvhBa+tdtmyZ8PT0FIaGhsLKykqEhISIvXv3tkutDdUJQGW9goODlbXX2rRpk+jevbuQy+XC19dX/PXXX1pb7/z584WLi4uQy+XC3t5ejBkzRsTFxbVLvc8//7xwdXUVcrlc2NraihEjRiiDpKFahdDc2ra0Zk2ub0PuDRRtXOO67levptd30qRJwtHRUcjlctG1a1cxadIkkZKS0mi9QrT9+rIdEhER6SR+BkhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDqJAUhERDrp/wPHbZxpihCHywAAAABJRU5ErkJggg==\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 500x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}